home *** CD-ROM | disk | FTP | other *** search
/ Shareware Grab Bag / Shareware Grab Bag.iso / 007 / yacc.arc / YACCPAR < prev   
Text File  |  1985-09-04  |  5KB  |  140 lines
  1. #define YYFLAG -1000
  2. #define YYERROR goto yyerrlab
  3. #define YYACCEPT return(0)
  4. #define YYABORT return(1)
  5.  
  6. /*      parser for yacc output  */
  7.  
  8. int yydebug = 0; /* 1 for debugging */
  9. YYSTYPE yyv[YYMAXDEPTH]; /* where the values are stored */
  10. int yychar = -1; /* current input token number */
  11. int yynerrs = 0;  /* number of errors */
  12. short yyerrflag = 0;  /* error recovery flag */
  13.  
  14. yyparse() {
  15.  
  16.         short yys[YYMAXDEPTH];
  17.         short yyj, yym;
  18.         register YYSTYPE *yypvt;
  19.         register short yystate, *yyps, yyn;
  20.         register YYSTYPE *yypv;
  21.         register short *yyxi;
  22.  
  23.         yystate = 0;
  24.         yychar = -1;
  25.         yynerrs = 0;
  26.         yyerrflag = 0;
  27.         yyps= &yys[-1];
  28.         yypv= &yyv[-1];
  29.  
  30.  yystack:    /* put a state and value onto the stack */
  31.  
  32.         if( yydebug  ) printf( "state %d, char 0%o\n", yystate, yychar );
  33.                 if( ++yyps> &yys[YYMAXDEPTH] ) { yyerror( "yacc stack overflow" ); return(1); }
  34.                 *yyps = yystate;
  35.                 ++yypv;
  36.                 *yypv = yyval;
  37.  
  38.  yynewstate:
  39.  
  40.         yyn = yypact[yystate];
  41.  
  42.         if( yyn<= YYFLAG ) goto yydefault; /* simple state */
  43.  
  44.         if( yychar<0 ) if( (yychar=yylex())<0 ) yychar=0;
  45.         if( (yyn += yychar)<0 || yyn >= YYLAST ) goto yydefault;
  46.  
  47.         if( yychk[ yyn=yyact[ yyn ] ] == yychar ){ /* valid shift */
  48.                 yychar = -1;
  49.                 yyval = yylval;
  50.                 yystate = yyn;
  51.                 if( yyerrflag > 0 ) --yyerrflag;
  52.                 goto yystack;
  53.                 }
  54.  
  55.  yydefault:
  56.         /* default state action */
  57.  
  58.         if( (yyn=yydef[yystate]) == -2 ) {
  59.                 if( yychar<0 ) if( (yychar=yylex())<0 ) yychar = 0;
  60.                 /* look through exception table */
  61.  
  62.                 for( yyxi=yyexca; (*yyxi!= (-1)) || (yyxi[1]!=yystate) ; yyxi += 2 ) ; /* VOID */
  63.  
  64.                 while( *(yyxi+=2) >= 0 ){
  65.                         if( *yyxi == yychar ) break;
  66.                         }
  67.                 if( (yyn = yyxi[1]) < 0 ) return(0);   /* accept */
  68.                 }
  69.  
  70.         if( yyn == 0 ){ /* error */
  71.                 /* error ... attempt to resume parsing */
  72.  
  73.                 switch( yyerrflag ){
  74.  
  75.                 case 0:   /* brand new error */
  76.  
  77.                         yyerror( "syntax error" );
  78.                 yyerrlab:
  79.                         ++yynerrs;
  80.  
  81.                 case 1:
  82.                 case 2: /* incompletely recovered error ... try again */
  83.  
  84.                         yyerrflag = 3;
  85.  
  86.                         /* find a state where "error" is a legal shift action */
  87.  
  88.                         while ( yyps >= yys ) {
  89.                            yyn = yypact[*yyps] + YYERRCODE;
  90.                            if( yyn>= 0 && yyn < YYLAST && yychk[yyact[yyn]] == YYERRCODE ){
  91.                               yystate = yyact[yyn];  /* simulate a shift of "error" */
  92.                               goto yystack;
  93.                               }
  94.                            yyn = yypact[*yyps];
  95.  
  96.                            /* the current yyps has no shift onn "error", pop stack */
  97.  
  98.                            if( yydebug ) printf( "error recovery pops state %d, uncovers %d\n", *yyps, yyps[-1] );
  99.                            --yyps;
  100.                            --yypv;
  101.                            }
  102.  
  103.                         /* there is no state on the stack with an error shift ... abort */
  104.  
  105.         yyabort:
  106.                         return(1);
  107.  
  108.  
  109.                 case 3:  /* no shift yet; clobber input char */
  110.  
  111.                         if( yydebug ) printf( "error recovery discards char %d\n", yychar );
  112.  
  113.                         if( yychar == 0 ) goto yyabort; /* don't discard EOF, quit */
  114.                         yychar = -1;
  115.                         goto yynewstate;   /* try again in the same state */
  116.  
  117.                         }
  118.  
  119.                 }
  120.  
  121.         /* reduction by production yyn */
  122.  
  123.                 if( yydebug ) printf("reduce %d\n",yyn);
  124.                 yyps -= yyr2[yyn];
  125.                 yypvt = yypv;
  126.                 yypv -= yyr2[yyn];
  127.                 yyval = yypv[1];
  128.                 yym=yyn;
  129.                         /* consult goto table to find next state */
  130.                 yyn = yyr1[yyn];
  131.                 yyj = yypgo[yyn] + *yyps + 1;
  132.                 if( yyj>=YYLAST || yychk[ yystate = yyact[yyj] ] != -yyn ) yystate = yyact[yypgo[yyn]];
  133.                 switch(yym){
  134.                         $A
  135.                 }
  136.                 goto yystack;  /* stack new state and value */
  137.  
  138.         }
  139.  
  140.